using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("MissionEntity")]
	public class MissionEntity : GameEntity
	{
		[Attribute38("MissionEntity.EmoteResponse")]
		public class EmoteResponse : MonoClass
		{
			public string m_soundName => method_4("m_soundName");

			public string m_stringTag => method_4("m_stringTag");

			public EmoteResponse(IntPtr address, string className)
				: base(address, className)
			{
			}

			public EmoteResponse(IntPtr address)
				: this(address, "EmoteResponse")
			{
			}
		}

		[Attribute38("MissionEntity.EmoteResponseGroup")]
		public class EmoteResponseGroup : MonoClass
		{
			public List<EmoteType> m_triggers => method_3<Class270<EmoteType>>("m_triggers")?.method_25();

			public List<EmoteResponse> m_responses => method_3<Class271<EmoteResponse>>("m_responses")?.method_25();

			public int m_responseIndex => method_2<int>("m_responseIndex");

			public EmoteResponseGroup(IntPtr address, string className)
				: base(address, className)
			{
			}

			public EmoteResponseGroup(IntPtr address)
				: this(address, "EmoteResponseGroup")
			{
			}
		}

		public enum ShouldPlayValue
		{
			Never,
			Once,
			Always
		}

		public static float TIME_TO_WAIT_BEFORE_ENDING_QUOTE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MissionEntity", "TIME_TO_WAIT_BEFORE_ENDING_QUOTE");

		public static float MINIMUM_DISPLAY_TIME_FOR_BIG_QUOTE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MissionEntity", "MINIMUM_DISPLAY_TIME_FOR_BIG_QUOTE");

		public static float DEFAULT_VO_DURATION => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "MissionEntity", "DEFAULT_VO_DURATION");

		public static List<EmoteType> STANDARD_EMOTE_RESPONSE_TRIGGERS => MonoClass.smethod_7<Class270<EmoteType>>(TritonHs.MainAssemblyPath, "", "MissionEntity", "STANDARD_EMOTE_RESPONSE_TRIGGERS")?.method_25();

		public bool m_enemySpeaking => method_2<bool>("m_enemySpeaking");

		public bool m_delayCardSoundSpells => method_2<bool>("m_delayCardSoundSpells");

		public List<EmoteResponseGroup> m_emoteResponseGroups => method_3<Class271<EmoteResponseGroup>>("m_emoteResponseGroups")?.method_25();

		public MissionEntity(IntPtr address, string className)
			: base(address, className)
		{
		}

		public MissionEntity(IntPtr address)
			: this(address, "MissionEntity")
		{
		}

		public new void OnTagChanged(TagDelta change)
		{
			method_8("OnTagChanged", change);
		}

		public new void NotifyOfStartOfTurnEventsFinished()
		{
			method_8("NotifyOfStartOfTurnEventsFinished");
		}

		public new void SendCustomEvent(int eventID)
		{
			method_8("SendCustomEvent", eventID);
		}

		public new void NotifyOfOpponentWillPlayCard(string cardId)
		{
			method_8("NotifyOfOpponentWillPlayCard", cardId);
		}

		public new void NotifyOfOpponentPlayedCard(Entity entity)
		{
			method_8("NotifyOfOpponentPlayedCard", entity);
		}

		public new void NotifyOfFriendlyPlayedCard(Entity entity)
		{
			method_8("NotifyOfFriendlyPlayedCard", entity);
		}

		public new void NotifyOfGameOver(TAG_PLAYSTATE gameResult)
		{
			method_8("NotifyOfGameOver", gameResult);
		}

		public new bool ShouldUseSecretClassNames()
		{
			return method_11<bool>("ShouldUseSecretClassNames", Array.Empty<object>());
		}

		public new void OnEmotePlayed(Card card, EmoteType emoteType, CardSoundSpell emoteSpell)
		{
			method_8("OnEmotePlayed", card, emoteType, emoteSpell);
		}

		public new bool IsEnemySpeaking()
		{
			return method_11<bool>("IsEnemySpeaking", Array.Empty<object>());
		}

		public new bool ShouldDelayCardSoundSpells()
		{
			return method_11<bool>("ShouldDelayCardSoundSpells", Array.Empty<object>());
		}

		public new bool DoAlternateMulliganIntro()
		{
			return method_11<bool>("DoAlternateMulliganIntro", Array.Empty<object>());
		}

		public bool IsHeroic()
		{
			return method_11<bool>("IsHeroic", Array.Empty<object>());
		}

		public bool IsClassChallenge()
		{
			return method_11<bool>("IsClassChallenge", Array.Empty<object>());
		}

		public bool IsNormal()
		{
			return method_11<bool>("IsNormal", Array.Empty<object>());
		}

		public void HandleMulliganTagChange()
		{
			method_8("HandleMulliganTagChange");
		}

		public void HandleStartOfTurn(int turn)
		{
			method_8("HandleStartOfTurn", turn);
		}

		public void HandleMissionEvent(int missionEvent)
		{
			method_8("HandleMissionEvent", missionEvent);
		}

		public void PlaySound(string soundPath, float waitTimeScale, bool parentBubbleToActor, bool delayCardSoundSpells)
		{
			method_8("PlaySound", soundPath, waitTimeScale, parentBubbleToActor, delayCardSoundSpells);
		}

		public void ShowBubble(string textKey, Notification.SpeechBubbleDirection direction, Actor speakingActor, bool destroyOnNewNotification, float duration, bool parentToActor, float bubbleScale)
		{
			method_8("ShowBubble", textKey, direction, speakingActor, destroyOnNewNotification, duration, parentToActor, bubbleScale);
		}

		public ShouldPlayValue InternalShouldPlayOpeningLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayOpeningLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayBossLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayBossLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayMissionFlavorLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayMissionFlavorLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayOnlyOnce()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayOnlyOnce", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayAdventureFlavorLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayAdventureFlavorLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayClosingLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayClosingLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayEasterEggLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayEasterEggLine", Array.Empty<object>());
		}

		public ShouldPlayValue InternalShouldPlayCriticalLine()
		{
			return method_11<ShouldPlayValue>("InternalShouldPlayCriticalLine", Array.Empty<object>());
		}

		public Notification.SpeechBubbleDirection GetDirection(Actor actor)
		{
			return method_11<Notification.SpeechBubbleDirection>("GetDirection", new object[1] { actor });
		}

		public bool ShouldPlayClosingLine(string line)
		{
			return method_11<bool>("ShouldPlayClosingLine", new object[1] { line });
		}

		public bool ShouldPlayCriticalLine(string line)
		{
			return method_11<bool>("ShouldPlayCriticalLine", new object[1] { line });
		}

		public bool ShouldPlayAdventureFlavorLine(string line)
		{
			return method_11<bool>("ShouldPlayAdventureFlavorLine", new object[1] { line });
		}

		public bool ShouldPlayMissionFlavorLine(string line)
		{
			return method_11<bool>("ShouldPlayMissionFlavorLine", new object[1] { line });
		}

		public bool ShouldPlayBossLine(string line)
		{
			return method_11<bool>("ShouldPlayBossLine", new object[1] { line });
		}

		public bool ShouldPlayEasterEggLine(string line)
		{
			return method_11<bool>("ShouldPlayEasterEggLine", new object[1] { line });
		}

		public bool ShouldPlayOpeningLine(string line)
		{
			return method_11<bool>("ShouldPlayOpeningLine", new object[1] { line });
		}

		public void InitEmoteResponses()
		{
			method_8("InitEmoteResponses");
		}

		public void PlayEmoteResponse(EmoteType emoteType, CardSoundSpell emoteSpell)
		{
			method_8("PlayEmoteResponse", emoteType, emoteSpell);
		}

		public void PlayNextEmoteReponse(EmoteResponseGroup responseGroup, Actor actor)
		{
			method_8("PlayNextEmoteReponse", responseGroup, actor);
		}

		public void CycleNextResponseGroupIndex(EmoteResponseGroup responseGroup)
		{
			method_8("CycleNextResponseGroupIndex", responseGroup);
		}
	}
}
